Django ORM ક્વેરી ઓપ્ટિમાઇઝેશન: select_related vs. prefetch_related

જેમ જેમ તમારી Django એપ્લિકેશન વધે છે, શ્રેષ્ઠ પ્રદર્શન જાળવવા માટે કાર્યક્ષમ ડેટાબેઝ ક્વેરીઝ મહત્વપૂર્ણ બની જાય છે. Django ORM ડેટાબેઝ હિટ્સને ઘટાડવા અને ક્વેરીની ગતિ સુધારવા માટે શક્તિશાળી સાધનો પ્રદાન કરે છે. આ સિદ્ધ કરવા માટે બે મુખ્ય તકનીકો છે select_related અને prefetch_related. આ વ્યાપક માર્ગદર્શિકા આ વિભાવનાઓને સમજાવશે, વ્યવહારુ ઉદાહરણો સાથે તેમનો ઉપયોગ દર્શાવશે, અને તમને તમારી ચોક્કસ જરૂરિયાતો માટે યોગ્ય સાધન પસંદ કરવામાં મદદ કરશે.

N+1 સમસ્યાને સમજવી

select_related અને prefetch_related માં ઊંડા ઉતરતા પહેલાં, તેઓ જે સમસ્યાનું નિરાકરણ લાવે છે તેને સમજવું આવશ્યક છે: N+1 ક્વેરી સમસ્યા. આ ત્યારે થાય છે જ્યારે તમારી એપ્લિકેશન ઓબ્જેક્ટ્સનો સમૂહ મેળવવા માટે એક પ્રારંભિક ક્વેરી ચલાવે છે, અને પછી દરેક ઓબ્જેક્ટ માટે સંબંધિત ડેટા પુનઃપ્રાપ્ત કરવા માટે વધારાની ક્વેરીઝ (N ક્વેરીઝ, જ્યાં N ઓબ્જેક્ટ્સની સંખ્યા છે) કરે છે.

લેખકો અને પુસ્તકોનું પ્રતિનિધિત્વ કરતા મોડેલો સાથે એક સરળ ઉદાહરણનો વિચાર કરો:

            class Author(models.Model):
    name = models.CharField(max_length=255)

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

            

              
                Copy
              
            
          

હવે, કલ્પના કરો કે તમે તેમના સંબંધિત લેખકો સાથે પુસ્તકોની સૂચિ પ્રદર્શિત કરવા માંગો છો. એક સાદી રીત આના જેવી દેખાઈ શકે છે:

            books = Book.objects.all()
for book in books:
    print(f"{book.title} by {book.author.name}")

            

              
                Copy
              
            
          

આ કોડ બધા પુસ્તકો મેળવવા માટે એક ક્વેરી જનરેટ કરશે અને પછી દરેક પુસ્તક માટે તેના લેખકને મેળવવા માટે એક ક્વેરી જનરેટ કરશે. જો તમારી પાસે 100 પુસ્તકો છે, તો તમે 101 ક્વેરીઝ ચલાવશો, જે નોંધપાત્ર પ્રદર્શન ઓવરહેડ તરફ દોરી જશે. આ N+1 સમસ્યા છે.

select_related નો પરિચય

select_related નો ઉપયોગ વન-ટુ-વન અને ફોરેન કી સંબંધોને સમાવતી ક્વેરીઝને ઓપ્ટિમાઇઝ કરવા માટે થાય છે. તે પ્રારંભિક ક્વેરીમાં સંબંધિત કોષ્ટક(કો)ને જોડીને કામ કરે છે, જે અસરકારક રીતે એક જ ડેટાબેઝ હિટમાં સંબંધિત ડેટા મેળવે છે.

ચાલો આપણે આપણા લેખકો અને પુસ્તકોના ઉદાહરણ પર પાછા જઈએ. N+1 સમસ્યાને દૂર કરવા માટે, આપણે આ રીતે select_related નો ઉપયોગ કરી શકીએ છીએ:

            books = Book.objects.all().select_related('author')
for book in books:
    print(f"{book.title} by {book.author.name}")

            

              
                Copy
              
            
          

હવે, Django એક જ, વધુ જટિલ ક્વેરી ચલાવશે જે Book અને Author કોષ્ટકોને જોડે છે. જ્યારે તમે લૂપમાં book.author.name ને ઍક્સેસ કરો છો, ત્યારે ડેટા પહેલેથી જ ઉપલબ્ધ હોય છે, અને કોઈ વધારાની ડેટાબેઝ ક્વેરીઝ કરવામાં આવતી નથી.

બહુવિધ સંબંધો સાથે select_related નો ઉપયોગ

select_related બહુવિધ સંબંધોને પાર કરી શકે છે. ઉદાહરણ તરીકે, જો તમારી પાસે એક મોડેલ સાથે ફોરેન કી છે જે બદલામાં બીજા મોડેલ સાથે ફોરેન કી ધરાવે છે, તો તમે એક જ વારમાં તમામ સંબંધિત ડેટા મેળવવા માટે select_related નો ઉપયોગ કરી શકો છો.

            class Country(models.Model):
    name = models.CharField(max_length=255)

class AuthorProfile(models.Model):
    author = models.OneToOneField(Author, on_delete=models.CASCADE)
    country = models.ForeignKey(Country, on_delete=models.CASCADE)

# Add country to Author
Author.profile = models.OneToOneField(AuthorProfile, on_delete=models.CASCADE, null=True, blank=True)

authors = Author.objects.all().select_related('profile__country')
for author in authors:
    print(f"{author.name} is from {author.profile.country.name if author.profile else 'Unknown'}")

            

              
                Copy
              
            
          

આ કિસ્સામાં, select_related('profile__country') એ AuthorProfile અને સંબંધિત Country ને એક જ ક્વેરીમાં મેળવે છે. ડબલ અન્ડરસ્કોર (__) નોટેશનની નોંધ લો, જે તમને સંબંધ વૃક્ષને પાર કરવાની મંજૂરી આપે છે.

select_related ની મર્યાદાઓ

select_related વન-ટુ-વન અને ફોરેન કી સંબંધો સાથે સૌથી વધુ અસરકારક છે. તે મેની-ટુ-મેની સંબંધો અથવા રિવર્સ ફોરેન કી સંબંધો માટે યોગ્ય નથી, કારણ કે મોટા સંબંધિત ડેટાસેટ્સ સાથે કામ કરતી વખતે તે મોટી અને બિનકાર્યક્ષમ ક્વેરીઝ તરફ દોરી શકે છે. આ પરિસ્થિતિઓ માટે, prefetch_related વધુ સારો વિકલ્પ છે.

prefetch_related નો પરિચય

prefetch_related ને મેની-ટુ-મેની અને રિવર્સ ફોરેન કી સંબંધોને સમાવતી ક્વેરીઝને ઓપ્ટિમાઇઝ કરવા માટે ડિઝાઇન કરવામાં આવ્યું છે. જોઇન્સનો ઉપયોગ કરવાને બદલે, prefetch_related દરેક સંબંધ માટે અલગ ક્વેરીઝ કરે છે અને પછી પરિણામોને "જોઇન" કરવા માટે પાયથોનનો ઉપયોગ કરે છે. જ્યારે આમાં બહુવિધ ક્વેરીઝ સામેલ હોય છે, ત્યારે મોટા સંબંધિત ડેટાસેટ્સ સાથે કામ કરતી વખતે તે જોઇન્સનો ઉપયોગ કરવા કરતાં વધુ કાર્યક્ષમ હોઈ શકે છે.

એવી પરિસ્થિતિનો વિચાર કરો જ્યાં દરેક પુસ્તકમાં બહુવિધ શૈલીઓ (genres) હોઈ શકે છે:

            class Genre(models.Model):
    name = models.CharField(max_length=255)

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    genres = models.ManyToManyField(Genre)

            

              
                Copy
              
            
          

તેમની શૈલીઓ સાથે પુસ્તકોની સૂચિ મેળવવા માટે, select_related નો ઉપયોગ કરવો યોગ્ય રહેશે નહીં. તેના બદલે, આપણે prefetch_related નો ઉપયોગ કરીએ છીએ:

            books = Book.objects.all().prefetch_related('genres')
for book in books:
    genre_names = [genre.name for genre in book.genres.all()]
    print(f"{book.title} ({', '.join(genre_names)}) by {book.author.name}")

            

              
                Copy
              
            
          

આ કિસ્સામાં, Django બે ક્વેરીઝ ચલાવશે: એક બધા પુસ્તકો મેળવવા માટે અને બીજી તે પુસ્તકોથી સંબંધિત બધી શૈલીઓ મેળવવા માટે. પછી તે શૈલીઓને તેમના સંબંધિત પુસ્તકો સાથે અસરકારક રીતે જોડવા માટે પાયથોનનો ઉપયોગ કરે છે.

રિવર્સ ફોરેન કીઝ સાથે prefetch_related

prefetch_related રિવર્સ ફોરેન કી સંબંધોને ઓપ્ટિમાઇઝ કરવા માટે પણ ઉપયોગી છે. નીચેના ઉદાહરણનો વિચાર કરો:

            class Author(models.Model):
    name = models.CharField(max_length=255)
    country = models.CharField(max_length=255, blank=True, null=True) # Added for clarity

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, related_name='books', on_delete=models.CASCADE)

            

              
                Copy
              
            
          

લેખકો અને તેમના પુસ્તકોની સૂચિ પુનઃપ્રાપ્ત કરવા માટે:

            authors = Author.objects.all().prefetch_related('books')
for author in authors:
    book_titles = [book.title for book in author.books.all()]
    print(f"{author.name} has written: {', '.join(book_titles)}")

            

              
                Copy
              
            
          

અહીં, prefetch_related('books') દરેક લેખક સાથે સંબંધિત તમામ પુસ્તકોને એક અલગ ક્વેરીમાં મેળવે છે, author.books.all() ને ઍક્સેસ કરતી વખતે N+1 સમસ્યાને ટાળે છે.

ક્વેરીસેટ સાથે prefetch_related નો ઉપયોગ

તમે સંબંધિત ઓબ્જેક્ટ્સ મેળવવા માટે કસ્ટમ ક્વેરીસેટ પ્રદાન કરીને prefetch_related ના વર્તનને વધુ કસ્ટમાઇઝ કરી શકો છો. જ્યારે તમારે સંબંધિત ડેટાને ફિલ્ટર કરવાની અથવા ઓર્ડર કરવાની જરૂર હોય ત્યારે આ ખાસ કરીને ઉપયોગી છે.

            from django.db.models import Prefetch

authors = Author.objects.prefetch_related(Prefetch('books', queryset=Book.objects.filter(title__icontains='django')))

for author in authors:
    django_books = author.books.all()
    print(f"{author.name} has written {len(django_books)} books about Django.")

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, Prefetch ઓબ્જેક્ટ આપણને એક કસ્ટમ ક્વેરીસેટ સ્પષ્ટ કરવાની મંજૂરી આપે છે જે ફક્ત એવા પુસ્તકોને જ મેળવે છે જેમના શીર્ષકોમાં "django" હોય છે.

prefetch_related ને ચેઇન કરવું

select_related ની જેમ જ, તમે બહુવિધ સંબંધોને ઓપ્ટિમાઇઝ કરવા માટે prefetch_related કોલ્સને ચેઇન કરી શકો છો:

            authors = Author.objects.all().prefetch_related('books__genres')

for author in authors:
  for book in author.books.all():
    genres = book.genres.all()
    print(f"{author.name} wrote {book.title} which is of genre(s) {[genre.name for genre in genres]}")

            

              
                Copy
              
            
          

આ ઉદાહરણ લેખક સાથે સંબંધિત પુસ્તકોને પ્રીફેચ કરે છે, અને પછી તે પુસ્તકો સાથે સંબંધિત શૈલીઓને પ્રીફેચ કરે છે. ચેઇન કરેલા prefetch_related નો ઉપયોગ તમને ઊંડાણપૂર્વક નેસ્ટેડ સંબંધોને ઓપ્ટિમાઇઝ કરવાની મંજૂરી આપે છે.

select_related vs. prefetch_related: યોગ્ય સાધન પસંદ કરવું

તો, તમારે select_related નો ઉપયોગ ક્યારે કરવો જોઈએ અને prefetch_related નો ઉપયોગ ક્યારે કરવો જોઈએ? અહીં એક સરળ માર્ગદર્શિકા છે:

• select_related: વન-ટુ-વન અને ફોરેન કી સંબંધો માટે ઉપયોગ કરો જ્યાં તમારે વારંવાર સંબંધિત ડેટાને ઍક્સેસ કરવાની જરૂર હોય. તે ડેટાબેઝમાં જોઇન કરે છે, તેથી તે સામાન્ય રીતે ઓછી માત્રામાં સંબંધિત ડેટા પુનઃપ્રાપ્ત કરવા માટે ઝડપી છે.
• prefetch_related: મેની-ટુ-મેની અને રિવર્સ ફોરેન કી સંબંધો માટે, અથવા મોટા સંબંધિત ડેટાસેટ્સ સાથે કામ કરતી વખતે ઉપયોગ કરો. તે અલગ ક્વેરીઝ કરે છે અને પરિણામોને જોડવા માટે પાયથોનનો ઉપયોગ કરે છે, જે મોટા જોઇન્સ કરતાં વધુ કાર્યક્ષમ હોઈ શકે છે. જ્યારે તમારે સંબંધિત ઓબ્જેક્ટ્સ પર કસ્ટમ ક્વેરીસેટ ફિલ્ટરિંગનો ઉપયોગ કરવાની જરૂર હોય ત્યારે પણ ઉપયોગ કરો.

સારાંશમાં:

• સંબંધનો પ્રકાર: select_related (ForeignKey, OneToOne), prefetch_related (ManyToManyField, reverse ForeignKey)
• ક્વેરીનો પ્રકાર: select_related (JOIN), prefetch_related (અલગ ક્વેરીઝ + પાયથોન જોઇન)
• ડેટાનું કદ: select_related (નાનો સંબંધિત ડેટા), prefetch_related (મોટો સંબંધિત ડેટા)

વ્યવહારુ ઉદાહરણો અને શ્રેષ્ઠ પદ્ધતિઓ

વાસ્તવિક-વિશ્વના દૃશ્યોમાં select_related અને prefetch_related નો ઉપયોગ કરવા માટે અહીં કેટલાક વ્યવહારુ ઉદાહરણો અને શ્રેષ્ઠ પદ્ધતિઓ છે:

• ઈ-કોમર્સ: ઉત્પાદનની વિગતો પ્રદર્શિત કરતી વખતે, ઉત્પાદનની કેટેગરી અને ઉત્પાદકને મેળવવા માટે select_related નો ઉપયોગ કરો. ઉત્પાદનની છબીઓ અથવા સંબંધિત ઉત્પાદનો મેળવવા માટે prefetch_related નો ઉપયોગ કરો.
• સોશિયલ મીડિયા: વપરાશકર્તાની પ્રોફાઇલ પ્રદર્શિત કરતી વખતે, વપરાશકર્તાની પોસ્ટ્સ અને ફોલોઅર્સને મેળવવા માટે prefetch_related નો ઉપયોગ કરો. વપરાશકર્તાની પ્રોફાઇલ માહિતી પુનઃપ્રાપ્ત કરવા માટે select_related નો ઉપયોગ કરો.
• કન્ટેન્ટ મેનેજમેન્ટ સિસ્ટમ (CMS): લેખ પ્રદર્શિત કરતી વખતે, લેખક અને કેટેગરી મેળવવા માટે select_related નો ઉપયોગ કરો. લેખના ટૅગ્સ અને ટિપ્પણીઓ મેળવવા માટે prefetch_related નો ઉપયોગ કરો.

સામાન્ય શ્રેષ્ઠ પદ્ધતિઓ:

• તમારી ક્વેરીઝને પ્રોફાઇલ કરો: ધીમી ક્વેરીઝ અને સંભવિત N+1 સમસ્યાઓને ઓળખવા માટે Django ના ડિબગ ટૂલબાર અથવા અન્ય પ્રોફાઇલિંગ સાધનોનો ઉપયોગ કરો.
• સરળ શરૂઆત કરો: એક સાદા અમલીકરણથી શરૂઆત કરો અને પછી પ્રોફાઇલિંગ પરિણામોના આધારે ઓપ્ટિમાઇઝ કરો.
• સંપૂર્ણપણે પરીક્ષણ કરો: ખાતરી કરો કે તમારા ઓપ્ટિમાઇઝેશન નવી બગ્સ અથવા પ્રદર્શનમાં ઘટાડો ન લાવે.
• કેશીંગનો વિચાર કરો: વારંવાર એક્સેસ થતા ડેટા માટે, પ્રદર્શનને વધુ સુધારવા માટે કેશીંગ મિકેનિઝમ્સ (દા.ત., Django નું કેશ ફ્રેમવર્ક અથવા Redis) નો ઉપયોગ કરવાનું વિચારો.
• ડેટાબેઝમાં ઇન્ડેક્સનો ઉપયોગ કરો: શ્રેષ્ઠ ક્વેરી પ્રદર્શન માટે આ અનિવાર્ય છે, ખાસ કરીને પ્રોડક્શનમાં.

ઉન્નત ઓપ્ટિમાઇઝેશન તકનીકો

select_related અને prefetch_related ઉપરાંત, અન્ય ઉન્નત તકનીકો છે જેનો ઉપયોગ તમે તમારી Django ORM ક્વેરીઝને ઓપ્ટિમાઇઝ કરવા માટે કરી શકો છો:

• only() અને defer(): આ પદ્ધતિઓ તમને ડેટાબેઝમાંથી કયા ફીલ્ડ્સ પુનઃપ્રાપ્ત કરવા તે સ્પષ્ટ કરવાની મંજૂરી આપે છે. ફક્ત જરૂરી ફીલ્ડ્સ પુનઃપ્રાપ્ત કરવા માટે only() નો ઉપયોગ કરો, અને જે ફીલ્ડ્સની તાત્કાલિક જરૂર નથી તેને બાકાત રાખવા માટે defer() નો ઉપયોગ કરો.
• values() અને values_list(): આ પદ્ધતિઓ તમને Django મોડેલ ઇન્સ્ટન્સને બદલે ડેટાને ડિક્શનરીઝ અથવા ટ્યુપલ્સ તરીકે પુનઃપ્રાપ્ત કરવાની મંજૂરી આપે છે. જ્યારે તમને મોડેલના ફીલ્ડ્સના માત્ર સબસેટની જરૂર હોય ત્યારે આ વધુ કાર્યક્ષમ હોઈ શકે છે.
• કાચી SQL ક્વેરીઝ (Raw SQL Queries): કેટલાક કિસ્સાઓમાં, Django ORM ડેટા પુનઃપ્રાપ્ત કરવાની સૌથી કાર્યક્ષમ રીત ન પણ હોય. તમે જટિલ અથવા અત્યંત ઓપ્ટિમાઇઝ્ડ ક્વેરીઝ માટે કાચી SQL ક્વેરીઝનો ઉપયોગ કરી શકો છો.
• ડેટાબેઝ-વિશિષ્ટ ઓપ્ટિમાઇઝેશન્સ: વિવિધ ડેટાબેઝ (દા.ત., PostgreSQL, MySQL) પાસે વિવિધ ઓપ્ટિમાઇઝેશન તકનીકો હોય છે. પ્રદર્શનને વધુ સુધારવા માટે ડેટાબેઝ-વિશિષ્ટ સુવિધાઓનું સંશોધન કરો અને તેનો લાભ લો.

આંતરરાષ્ટ્રીયકરણની બાબતો

વૈશ્વિક પ્રેક્ષકો માટે Django એપ્લિકેશન્સ વિકસાવતી વખતે, આંતરરાષ્ટ્રીયકરણ (i18n) અને સ્થાનિકીકરણ (l10n) ને ધ્યાનમાં લેવું મહત્વપૂર્ણ છે. આ તમારી ડેટાબેઝ ક્વેરીઝને ઘણી રીતે અસર કરી શકે છે:

• ભાષા-વિશિષ્ટ ડેટા: તમારે તમારા ડેટાબેઝમાં સામગ્રીના અનુવાદો સંગ્રહિત કરવાની જરૂર પડી શકે છે. અનુવાદોનું સંચાલન કરવા અને તમારી ક્વેરીઝ ડેટાનું સાચું ભાષા સંસ્કરણ પુનઃપ્રાપ્ત કરે તેની ખાતરી કરવા માટે Django ના i18n ફ્રેમવર્કનો ઉપયોગ કરો.
• અક્ષર સમૂહો અને કોલેશન્સ (Character Sets and Collations): ભાષાઓ અને અક્ષરોની વિશાળ શ્રેણીને સમર્થન આપવા માટે તમારા ડેટાબેઝ માટે યોગ્ય અક્ષર સમૂહો અને કોલેશન્સ પસંદ કરો.
• સમય ઝોન (Time Zones): તારીખો અને સમય સાથે કામ કરતી વખતે, સમય ઝોન પ્રત્યે સાવચેત રહો. તારીખો અને સમયને UTC માં સંગ્રહિત કરો અને તેમને પ્રદર્શિત કરતી વખતે વપરાશકર્તાના સ્થાનિક સમય ઝોનમાં રૂપાંતરિત કરો.
• ચલણ ફોર્મેટિંગ (Currency Formatting): કિંમતો પ્રદર્શિત કરતી વખતે, વપરાશકર્તાના લોકેલના આધારે યોગ્ય ચલણ પ્રતીકો અને ફોર્મેટિંગનો ઉપયોગ કરો.

નિષ્કર્ષ

માપી શકાય તેવી અને કાર્યક્ષમ વેબ એપ્લિકેશન્સ બનાવવા માટે Django ORM ક્વેરીઝને ઓપ્ટિમાઇઝ કરવું આવશ્યક છે. select_related અને prefetch_related ને સમજીને અને અસરકારક રીતે ઉપયોગ કરીને, તમે ડેટાબેઝ ક્વેરીઝની સંખ્યાને નોંધપાત્ર રીતે ઘટાડી શકો છો અને તમારી એપ્લિકેશનની એકંદર પ્રતિભાવશીલતામાં સુધારો કરી શકો છો. તમારી ક્વેરીઝને પ્રોફાઇલ કરવાનું, તમારા ઓપ્ટિમાઇઝેશનનું સંપૂર્ણ પરીક્ષણ કરવાનું અને પ્રદર્શનને વધુ વધારવા માટે અન્ય ઉન્નત તકનીકોનો વિચાર કરવાનું યાદ રાખો. આ શ્રેષ્ઠ પદ્ધતિઓને અનુસરીને, તમે ખાતરી કરી શકો છો કે તમારી Django એપ્લિકેશન તેના કદ અથવા જટિલતાને ધ્યાનમાં લીધા વિના, એક સરળ અને કાર્યક્ષમ વપરાશકર્તા અનુભવ પ્રદાન કરે છે. એ પણ ધ્યાનમાં લો કે શ્રેષ્ઠ પ્રદર્શન માટે સારી ડેટાબેઝ ડિઝાઇન અને યોગ્ય રીતે ગોઠવેલ ઇન્ડેક્સ અનિવાર્ય છે.